package com.jason.methodextend;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

class DeadlockExample {

    // 创建两个对象作为锁
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) { // 线程获取lock1的锁
            System.out.println(Thread.currentThread().getName() + " 获取了 lock1 的锁");

            try {
                // 模拟一些耗时操作
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 尝试获取lock2的锁，但此时它可能已经被另一个线程持有
            synchronized (lock2) {
                System.out.println(Thread.currentThread().getName() + " 获取了 lock2 的锁");
            }
        }
    }

    public void method2() {
        synchronized (lock2) { // 线程获取lock2的锁
            System.out.println(Thread.currentThread().getName() + " 获取了 lock2 的锁");

            try {
                // 模拟一些耗时操作
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 尝试获取lock1的锁，但此时它可能已经被另一个线程持有
            synchronized (lock1) {
                System.out.println(Thread.currentThread().getName() + " 获取了 lock1 的锁");
            }
        }
    }

}

public class test {
    class Animal {}
    class Dog extends Animal {}
    class Cat extends Animal {}
    public void main(String[] args) {
        DeadlockExample deadlockExample = new DeadlockExample();
        // 创建两个线程分别调用两个方法
        new Thread(() -> deadlockExample.method1(), "Thread-1").start();
        new Thread(() -> deadlockExample.method2(), "Thread-2").start();
        System.out.println(Thread.currentThread().getName() + " main  ");
        ReentrantLock reentrantLock =new ReentrantLock();


        List<? super Animal> dogList = new ArrayList<>(); // 合法，列表可以是Dog或Dog的父类型列表
        dogList.add(new Dog()); // 合法，因为Dog是列表元素类型的子类型或本身
        dogList.add(new Animal()); // 编译错误，除非列表是Animal类型，但这里只是? super Dog
// 读取时需要类型转换，因为编译器不知道确切的类型
//        if (dogList instanceof List<Dog>) {
//            Dog dog = ((List<Dog>) dogList).get(0); // 显式类型转换
//        }


//        List<? extends Animal> animals = new ArrayList<Dog>(); // 合法，Dog是Animal的子类
//        Animal a = animals.get(0); // 合法，因为可以安全地将Dog视为Animal
//        animals.add(new Animal()); // 编译错误，无法确定animals的具体类型，不能添加除null外的元素
//        animals.add(new Dog()); // 同样编译错误
//        animals.add(null); // 合法，因为null可以赋给任何对象类型

        List<? super  CharSequence> charSequences = new ArrayList<CharSequence>();
        charSequences.add("123");
//        charSequences.add(123);

        List<? super String> list = new ArrayList<CharSequence>();
        list.add("123");
    }
}